﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.ServiceModel;
using System.Text;
using System.Threading;
[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession,ConcurrencyMode=ConcurrencyMode.Multiple)]
public class Service:IService
{
    //컨트롤네임으로 접근하기위한 문자열 상수
    #region Client-Control Name
    /// <summary>
    /// 호텔체크버튼
    /// </summary>
    const string chkHotel = "chkHotel";

    /// <summary>
    /// 콘도체크버튼
    /// </summary>
    const string chkCondo = "chkCondo";

    /// <summary>
    /// 여관체크버튼
    /// </summary>
    const string chkInn = "chkInn";

    /// <summary>
    /// 첫번째 주사위 텍스트박스
    /// </summary>
    const string txtFirstDice = "txtFirstDice";

    /// <summary>
    /// 두번째 주사위 텍스트박스
    /// </summary>
    const string txtSecondDice = "txtSecondDice";

    /// <summary>
    /// 로그인 버튼
    /// </summary>
    const string btnLogin = "btnLogin";

    /// <summary>
    /// 게임시작 버튼
    /// </summary>
    const string btnStart = "btnStart";

    /// <summary>
    /// 주사위 버튼
    /// </summary>
    const string btnDice = "btnDice";

    /// <summary>
    /// 땅사기 버튼
    /// </summary>
    const string btnBuyEstate = "btnBuyEstate";

    /// <summary>
    /// 땅팔때 버튼
    /// </summary>
    const string btnSellEstate = "btnSellEstate";

    /// <summary>
    /// Id입력창
    /// </summary>
    const string txtId = "txtId";

    /// <summary>
    /// 메시지입력창
    /// </summary>
    const string txtMessage = "txtMessage";

    /// <summary>
    /// 채팅을 하는 텍스트박스
    /// </summary>
    const string txtChat = "txtChat";

    /// <summary>
    /// 소유자나타냄
    /// </summary>
    const string lblOwner = "lblOwner";

    /// <summary>
    /// 지금의 타입을 나타냄.
    /// </summary>
    const string lblType = "lblType";
    
    /// <summary>
    /// 위치를 나타냄
    /// </summary>
    const string txtArea = "txtArea";

    /// <summary>
    /// 벌금을 나타냄
    /// </summary>
    const string lblPenalty = "lblPenalty";
    /// <summary>
    /// 지금가지고 있는 현금을 나타냄.
    /// </summary>
    const string lblCash = "lblCash";

    #endregion
    
    /// <summary>
    /// 주사위를 던졌을 때 저장하는 곳
    /// </summary>
    int first, second;
    
    ICallback Callback;//콜백을 임시로 저장하는 곳. 유저에 등록되기전...
    User user;//자신의 아이디와 콜백을 저장하는 곳.
    static Thread timer = new Thread(new ThreadStart(Timer));//Count를 세는 곳
    static bool gaming = false;//게임을 하고 있을 경우 true가 되어 접근 못하게 함.
    static SynchronizedCollection<User> userList = new SynchronizedCollection<User>();//유저리스트를 추가시킴.
    static bool counter = false;//초단위로 셀건지 결정
    static Area[] GameBoard = new Area[AreaNum];//유저가 돌아다니는 곳.
    static int userNumber = 0;//턴을 정하는 수

    static readonly int AreaNum = 22;//보드에 깔리는 지역의 수

    const int MaxTime = 5;//5초안에 결정
    public static int Count//초를 나타냄.
    {
        set;
        get;
    }

    private static void Timer()
    {
        while (counter)
        {
            Thread.Sleep(1000);//1초쉬고
            Count++;//+1
            foreach (var user in userList)
            {
                user.Callback.TimerCount(Count);//콜백을 다 보냄.
            }
            if (Count >= MaxTime && userList.Count != 0)//카운터가 맥스타임보다 크거나 같을 경우 혹은 유저리스트에서 유저가 있다면
            {
                userList[userNumber++].Callback.ControlEnable(btnDice, false);//이제 그만 받아준다.
                userNumber %= userList.Count;
                userList[userNumber].Callback.ControlEnable(btnDice, true);//시간이 되면 다음턴으로 넘기기...
                Count %= MaxTime;
            }
        }
    }

    public User getOwner()
    {
        if (user.Area is Estate)
        {
            return (user.Area as Estate).Owner;
        }
        return null;
    }
    public void Start()
    {
        Callback = OperationContext.Current.GetCallbackChannel<ICallback>();//
        Callback.ControlEnable(btnLogin, true);
        Callback.ControlFocus(txtId);
    }
    public void Login(string id)
    {
        if (id == "" || id == null)
        {
            Callback.Message("아이디를 찍어주세요.");
            return;
        }
        if (gaming)
        {
            Callback.Message("게임중입니다.");
            return;
        }
        lock (userList.SyncRoot)
        {
            if (userList.Count != 0&&userList.Count<4)
            {
                foreach (var user in userList)
                {
                    if (user.Id == id)
                    {
                        Callback.Message("로그인이 되어진 상태입니다. ");
                        //여러가지 컨트롤을 불활성화시킴
                        Callback.ControlEnable(btnDice, false);//주사위버튼
                        Callback.ControlEnable(btnStart, false);//게임시작
                        Callback.ControlEnable(txtChat, false);//채팅하는 곳을 봉쇄
                        return;
                    }
                }
            }
            //서버쪽 유저리스트에 등록시킴.
            this.user = new User(id);//일단, user에 새로운 id를 가지는 유저를 만듬
            this.user.Callback = Callback;//콜백도 등록함

            this.user.Callback.ControlEnable(txtChat, true);//채팅창은 앞으로 쓰기때문에 활성화시킴.
            this.user.Callback.ControlEnable(btnLogin, false);//로그인버튼은 앞으로 안 쓸것임으로 비활성화
            this.user.Callback.ControlEnable(txtId, false);//id도 게임에 들어왔으므로, 비활성화.
            
            userList.Add(this.user);//리스트에 추가를 시킴.
            userList[0].Callback.ControlEnable(btnStart, true);//게임시작은 방장(여기선 처음으로 들어온 자를 방장이라함)
        }
        Callback.Message("로그인 했습니다. "+id);
    }
    public void Quit()
    {
        if (user==null)//user를 만들지 않고 곧바로 종료할때
        {
            return;
        }
        lock (userList.SyncRoot)
        {
            foreach (var estate in user.Fortunes.Values)
            {//모든 재산을 클리어함.
                estate.Hotel = false;
                estate.Inn = false;
                estate.Condo = false;
                estate.Owner = null;
            }
            user.Fortunes.Clear();//자신의 재산목록의 다 지우고
            if (userList.Contains(user))
            {
                userList.Remove(user);//자기자신도 지운다.
            }
            if (userList.Count == 0)
            {
                gaming = false;//userlist에 들어간 사람이 0이면, 게임이 안하고 있는 상황이므로, 그냥 고~!
            }
        }
    }
    public void InitGame()
    {
        //방장이 게임시작버튼을 누르면, 이것이 호출됨.
        //방장만 실행가능
        //방장인지 아닌지 확인
        if (!(userList[0].Equals(this.user)))//방장이 아니면,
        {
            Callback.Message("방장만 게임시작가능합니다.");
            return;
        }
        GameBoard = new Area[AreaNum];
        GameBoard[0] = new EventZone("출발지");
        GameBoard[1] = new Estate("한국", 5000);
        GameBoard[2] = new Estate("일본", 5500);
        GameBoard[3] = new Estate("중국", 4000);
        GameBoard[4] = new Estate("태국", 3800);
        GameBoard[5] = new Estate("필리핀", 3800);
        
        GameBoard[6] = new EventZone("무인도");
        GameBoard[7] = new Estate("호주", 5000);
        GameBoard[8] = new Estate("아르헨티나", 3000);
        GameBoard[9] = new Estate("멕시코", 3500);
        GameBoard[10] = new Estate("미국", 6800);
        
        GameBoard[11] = new EventZone("기금입금");
        GameBoard[12] = new Estate("러시아", 4300);
        GameBoard[13] = new Estate("영국", 5800);
        GameBoard[14] = new Estate("프랑스", 4500);
        GameBoard[15] = new Estate("스페인", 4700);
        GameBoard[16] = new Estate("이탈리아", 5000);

        GameBoard[17] = new EventZone("기금출금");
        GameBoard[18] = new Estate("터키", 3500);
        GameBoard[19] = new Estate("UAE", 5000);
        GameBoard[20] = new Estate("인도", 3900);
        GameBoard[21] = new Estate("몽고", 2900);

        foreach (var user in userList)
        {
            user.Position = 0;//현인덱스값
            user.Area = GameBoard[user.Position];//현위치
            user.Money = 100000;//돈은 10만
            user.Muindo = 0;//무인도 갇혔을 때을 대비한 값이지만, 지금은 무인도가 아니므로 0임.
        }
        foreach (var user in userList)
        {
            foreach (var _user in userList)//각개 리스트에 보냄.
            {
                user.Callback.GameBoardPlayerDisplay(_user.Area.Title, _user.Id);//출발지에 아이디를 표시합니다.
            }
            user.Callback.Message("게임이 초기화되었습니다.");
            user.Callback.ControlEnable(btnStart, false);
        }
        gaming = true;//최종적으로 시작함.
        counter = true;//시각을 매기고,
        timer.Start();//초를 매김스타트함.
        userList[0].Callback.ControlEnable(btnDice,true);//방장만 주사위를 눌릴 수 있게 해줍니다.
                
    }
    public void RollDice()
    {
        foreach (var refresh in userList)
        {
            refresh.Callback.GameBoardPlayerRemove(user.Area.Title, user.Id);//일단 모든 유저의 디스플레이에서 자신의 위치를 지움.
        }
        #region 주사위굴림
        Random random=new Random();
        first = random.Next(6) + 1;//주사위의 범위는 !~6까지
        second = random.Next(6) + 1;
        bool equal = (first == second);
        Callback.Message(string.Format("첫번째 주사위는 {0}{2}두번째 주사위는 {1}", first, second, Environment.NewLine));
        #endregion
        #region 무인도 관련 연산
        //무인도에 있을 땐
        if (user.Area.Title == "무인도")
        {
            Callback.Message("지금 현재 무인도 있습니다.");
            if (user.Muindo > 1)//1턴 이상 남았을 때
            {
                Callback.Message("남아야 할 횟수만큼 남습니다. 지금 현재 남은 횟수는" + user.Muindo);
                if (equal)//굴렸을 때 
                {
                    Callback.Message("따블이으므로, 무인도를 탈출합니다. 다음에 탈출합니다.");
                    user.Muindo = 0;
                    Count = 0;
                    Callback.ControlEnable(btnDice,false);
                    return;//따블이지만, 다음번에 통과합니다.
                }
                else
                {
                    Callback.Message("무인도에서 한턴을 쉽니다.");
                    user.Muindo--;//한턴을 쉬면서 제한을 1증가시킵니다.
                    Count = 0;//카운트0로 리셋
                    Callback.ControlEnable(btnDice, false);
                    return;
                }
            }
            if (user.Muindo == 1)
            {
                if (equal)
                {
                    Callback.Message("따블이며, 남은 횟수가 1이므로, 한번 던져 바로 탈출합니다.");
                    user.Muindo = 0;//이제 무인도를 탈출합니다.
                    Count = MaxTime; //시간을 다시 줍니다.
                    Callback.ControlEnable(btnDice, true);//주사위버튼 활성화시킴.
                    return;
                }
                else
                {
                    Callback.Message("따블이 아니므로, 다음에 탈출합니다.");
                    user.Muindo = 0;//일단 무인도에 갇혀야하는 턴을 0으로 맞추고
                    Callback.ControlEnable(btnDice, false);//주사위는 비활성화시킴.
                    return;
                }
            }
        }
        #endregion
        #region 유저이동
        user.Position += (first + second);//세컨드와 퍼스트를 합쳐 이동시킴.
        
        if (user.Position >= AreaNum)//포지션의 수가 AreaNum(지역수)보다 크면.
        {
            user.Callback.Message("한바퀴를 돌았으므로 돈을 지급합니다.");
            user.Money += 20000;//돈을 줍니다.
        }
        user.Position %= AreaNum;//나머지연산을 합니다.
        
        user.Area = GameBoard[user.Position];//Area을 매치시켜줍니다.
        foreach (var refresh in userList)
        {
            refresh.Callback.GameBoardPlayerDisplay(user.Area.Title, user.Id);//간곳에 표시를 하게 콜백해줍니다.
        }

        Callback.Message((first + second) + "칸을 이동합니다. " + user.Area.Title + "으로 이동했습니다.");

        #endregion
        #region 클라이언트관련
        bool canBuy=false;//살수있는 땅인가?
        bool canSell = false;//팔수 있는 땅인가?
        bool hasHotel = false, hasCondo = false, hasInn = false;//각종 숙박의 유무
        string OwnerId = null ;//땅의 주인
        string areaType;//땅의 타입
        int Penalty = 0;//땅주인에게 줄 벌금
        string strPenalty = "";//벌금의 스트링형
        float PenaltyRate = 0.3f;//땅값에 30%을 징수
        
        if (user.Area is Estate)//현위치가 Estate일경우
        {
            Estate estate = user.Area as Estate;//Estate로 변환시키고
            areaType = "부동산지역";//타입을 부동산지역으로 지정
            
            if (estate.Owner == null)//주인이 없을 경우
            {
                canBuy = true;//살수있음
                canSell = false;//팔수없음
                OwnerId = "주인없음";//주인없음이라 표시
            }

            else if (estate.Owner.Id == user.Id)//현재 땅주인이 현 지금 유저일경우
            {
                canBuy = false;//살수없음
                canSell = true;//팔수있음
            }
            else//주인도 있고 현재땅주인이 아닐 경우에 벌금을 계산함.
            {
                Penalty = (int)((float)estate.BuyMoney * PenaltyRate);//땅의 패널티를 먼저 계산
                if (estate.Hotel)//호텔이 있나?
                {
                    Penalty += (int)((float)Lodging.Hotel * PenaltyRate);//호텔의 값을 캐스팅하여 페널티율에 의해 계산
                }
                if (estate.Condo)
                {
                    Penalty += (int)((float)Lodging.Condo * PenaltyRate);//콘도의 값을 캐스팅하여 페널티율에 의해 계산
                }
                if (estate.Inn)
                {
                    Penalty += (int)((float)Lodging.Inn * PenaltyRate);//여관의 값을 캐스팅하여 페널티율에 의해 계산
                }
                OwnerId = estate.Owner.Id;
                foreach (User getter in userList)//리스트에서 벌금을 가져옴.
                {
                    if (getter.Id == OwnerId)//게터인것을 골라...
                    {
                        if (Penalty > user.Money)
                        {
                            user.Callback.Message("벌금지급을 하지못하여 부도가 났습니다.");
                            Quit();//게임을 끝냅니다.
                        }
                        else
                        {
                            getter.Money += Penalty;//오너에겐 벌금을 받음.
                            user.Money -= Penalty;//걸린 사람에게 벌금을 걷고
                        }
                        break;
                    }
                }
                canBuy = false;//사거나
                canSell = false;//팔지 못함
            }
            hasHotel = estate.Hotel;//호텔 유무를 표시하기위해 저장
            hasCondo = estate.Condo;//콘도 유무를 표시하기위해 저장
            hasInn = estate.Inn;//여관 유무를 표시하기위해 저장
            
            strPenalty = Penalty.ToString();

        }
        else//이벤트지역이므로 사지도 팔지도 못함.
        {
            canBuy = false;
            canSell = false;
            OwnerId = "";
            areaType = "이벤트지역";
            strPenalty = "";
            user.Area.Execute(user);//이벤트지역에 맞는 것을 행동을 취함.
        }
        
        
        Callback.ControlTextChanged(lblCash, user.Money.ToString());//돈을 갱신

        Callback.ControlTextChanged(lblPenalty, strPenalty);//벌금갱신
        Callback.ControlTextChanged(lblOwner, OwnerId);//소유자 갱신
       
        Callback.CheckChanged(chkHotel, canSell, hasHotel);//호텔을 지어진것 과 팔 수있는가를 판단
        Callback.CheckChanged(chkCondo, canSell, hasCondo);//콘도을 지어진것 과 팔 수있는가를 판단
        Callback.CheckChanged(chkInn, canSell, hasInn);//여관을 지어진것 과 팔 수있는가를 판단

        Callback.ControlTextChanged(lblType, areaType);//땅타입지정함.
        Callback.ControlTextChanged(txtArea, user.Area.Title);//지금 현위치의 제목을 표시함.
        Callback.ControlTextChanged(txtFirstDice, first.ToString());//첫번째 주사위를 표시
        Callback.ControlTextChanged(txtSecondDice, second.ToString());//두번째 주사위를 표시
        
        Callback.ControlEnable(btnBuyEstate, canBuy);//살수있는지 없는지를 지정함.
        Callback.ControlEnable(btnSellEstate, canSell);//팔수있는지 없는지를 지정함.
        
        #endregion
        #region 더블과 관련된 연산
        if (equal)
        {
            Count = MaxTime;//더블은 한번 더 함. 시간을 한번 더 줌.
        }
        user.Callback.ControlEnable(btnDice,equal);
        if (equal)
        {
            user.Callback.ControlFocus(btnDice);
        }
        else
        {
            user.Callback.ControlFocus(txtChat);
        }
        #endregion
    }
    /// <summary>
    /// 땅을 판다.
    /// </summary>
    /// <param name="estate">클라이언트에서 넘어올 수 있는 값(고로 레퍼런스가 같지 않을 있음)</param>
    public void Buy(string title)//몇개의 연산을 더 추가, 한눈에 알아보기위해 몰아 넣었음.
    {
        Estate estate=null;
        foreach (Area area in GameBoard)
        {
            if (area.Title == title && area is Estate)
            {
                estate = area as Estate;
                break;
            }
        }
        if (estate == null)
        {
            Callback.Message(title+"가 없습니다.");
            return;//팔 수 없습니다.
        }
        //estate안에는 타이틀에 맞는 땅이 들어감.
        //유저가 가지고 있는 땅 검색
        if (user.Money > estate.BuyMoney && estate.Owner == null && !user.Fortunes.ContainsKey(title))//유저가 사는 가격에 비해 현찰이 더 맣고, 땅주인 없고, 유저재산목록중에 포함되지 않았을 경우
        {
            user.Money -= estate.BuyMoney;//재산을 삽니다.
            estate.Owner = user;//재산 소유주를 정함.
            user.Fortunes.Add(estate.Title, estate);//유저의 재산목록에 추가시킵니다.
            Callback.Message(estate.Title + "을 " + user + "님의 재산에 추가시켰습니다.");
            Callback.ControlEnable(btnBuyEstate, false);//버튼을 비활성화시킵니다.
            Callback.ControlEnable(btnSellEstate, true);//버튼을 활성화시킵니다.
            Callback.ControlTextChanged(lblOwner, user.Id);//땅주인을 바꾸고.
            Callback.ControlTextChanged(lblCash, user.Money.ToString());//깍여진 돈을 업데이트하고.
            Callback.GameBoardOwnerChanged(estate.Title, estate.Owner.Id);//게임판상의 주인을 업데이트시킵니다.
        }
        else
        {
            Callback.Message("재산목록에 있습니다.");
        }
    }
    public void Sell(string title)//원래의 계획은 현위치만 바로 팔게 할려고 했지만, 아무곳에서도 타이틀만 넣으면 되게끔 만듬
    {                               //하지만, 게임상에선 여전히 현위치에서만 됨
        if (user.Fortunes.ContainsKey(title))//재산목록에 땅이 있을 경우
        {
            Estate estate = user.Fortunes[title];//재산의 목록을 찾아 저장함.
            user.Money += estate.SellMoney;//유저머니를 더함.
            estate.Owner = null;//땅의 주인을 없애고
            user.Fortunes.Remove(title);//재산의 목록에서 지움
            Callback.Message("팔렸습니다.");
            //이제 지워졌으므로 
            Callback.ControlEnable(btnSellEstate, false);//팔수없게 만듬
            Callback.ControlEnable(btnBuyEstate, true);//살수있게 만듬.
            Callback.ControlFocus(btnBuyEstate);//포커스를 다시 사는 버튼에 맞춤.
            Callback.ControlTextChanged(lblOwner, "주인없음");//주인없음을 표시함.
            Callback.ControlTextChanged(lblCash, user.Money.ToString());//유저의 돈을 변환시켜 표시
            Callback.GameBoardOwnerChanged(estate.Title, "");//게임판상에서 지움.
            return;
        }
        else
        {
            Callback.Message("재산목록에 없습니다.");
            return;
        }
    }
    
    public void Display()
    {
        
    }

    [Conditional("DEBUG")]
    private static void LogMessage(string message)
    {
        Console.Write(message);
        Console.CursorLeft = 40;
        Console.WriteLine(DateTime.Now);
    }
    public void Message(string message)
    {
        LogMessage(message);
        Callback.Message(message);
    }
    public void BuyLodging(string title,Lodging lodging)//파는곳과 건축물을 삼.
    {
        if (user.Fortunes.ContainsKey(title))//건축물을 세우는 곳이 재산목록에 있어야함
        {
            var fortune = user.Fortunes[title];//건축물을 세우는 곳의 재산목록에서
            int value = (int)lodging;//해당 건축물에 맞는 가격을 구하고
            switch (lodging)
            {
                case Lodging.Inn://세우고자 하는 건축물이 여관일때
                    if (!fortune.Inn)//여관이 없으면
                    {
                        if (user.Money >= value)//여관이 지역에 없고 돈이 풍족할 때...
                        {
                            user.Money -= value;//유저의 돈에서 지급을 하고
                            fortune.Inn = true;//여관을 세웁니다.
                            Callback.Message("여관을 세웠습니다.");

                        }
                        else
                        {
                            Callback.Message("돈이 없습니다.");
                            Callback.ControlEnable(chkInn, false);//돈이 없는데 날라왔기때문에 또다시눌리지 않게 하기 위해 
                            //체크박스를 비활성화시킴.
                        }
                    }
                    else
                    {
                        Callback.Message("지역에 여관이 이미 있습니다.");
                    }
                    break;
                case Lodging.Condo://위의 여관과 동일
                    if (!fortune.Condo)
                    {
                        if (user.Money >= value)//콘도가 지역에 없고 돈이 풍족할 때...
                        {
                            user.Money -= value;
                            fortune.Condo = true;
                            Callback.Message("콘도를 세웠습니다.");
                        }
                        else
                        {
                            Callback.Message("돈이 없습니다.");
                            Callback.ControlEnable(chkInn, false);
                        }
                    }
                    else
                    {
                        Callback.Message("지역에 콘도가 이미 있습니다.");
                    }
                    break;
                case Lodging.Hotel://위의 여관과 동일
                    if (!fortune.Hotel)
                    {
                        if (user.Money >= value)//호텔이 지역에 없고 돈이 풍족할 때...
                        {
                            user.Money -= value;
                            fortune.Hotel = true;
                            Callback.Message("호텔을 세웠습니다.");
                        }
                        else
                        {
                            Callback.Message("돈이 없습니다.");
                            Callback.ControlEnable(chkInn, false);
                        }
                    }
                    else
                    {
                        Callback.Message("지역에 호텔이 이미 있습니다.");
                    }
                    break;
                default:
                    Callback.Message("잘못되어진 양식입니다.");
                    break;
            }
            Callback.ControlTextChanged(lblCash, user.Money.ToString());
        }
        else
        {
            Callback.Message("사려는 재산목록에 없습니다.");
        }
    }
    public void SendMessage(string message)
    {
        if (userList.Count == 0)
        {
            Callback.Message(message);
        }
        foreach (var user in userList)
        {
            user.Callback.Message(this.user.Id+message);
        }
    }
    public void SellLodging(string title,Lodging lodging)
    {
        if (user.Fortunes.ContainsKey(title))
        {
            var fortune = user.Fortunes[title];
            int value = (int)((double)lodging * 0.6);//팔땐 60%만 받음.
            switch (lodging)
            {
                case Lodging.None:
                    Callback.Message("행동을 아무것도 안합니다.");//없음.
                    break;
                case Lodging.Inn://여관을 팔려고 합니다.
                    if (fortune.Inn)//여관이 있다면
                    {
                        fortune.Inn = false;//여관을 팔고
                        user.Money += value;//여관에 해당하는 값을 받습니다.
                        Callback.Message("여관을 팝니다.");
                    }
                    else
                    {
                        Callback.Message("여관을 짖지 않았습니다.");
                    }
                    break;
                case Lodging.Condo://콘도를 팔려고 합니다.
                    if (fortune.Condo)//콘도가 있다면...
                    {
                        fortune.Condo = false;//콘도를 팔고
                        user.Money += value;//콘도에 해당하는 값을 받습니다.
                        Callback.Message("콘도을 팝니다.");
                    }
                    else
                    {
                        Callback.Message("콘도를 짖지 않았습니다.");
                    }
                    break;
                case Lodging.Hotel://위와 동일
                    if (fortune.Hotel)
                    {
                        fortune.Hotel = false;
                        user.Money += value;
                        Callback.Message("호텔를 팝니다.");
                    }
                    else
                    {
                        Callback.Message("호텔을 짖지 않았습니다.");
                    }
                    break;
                default:
                    Callback.Message("잘못되어진 양식입니다.");
                    break;
            }
            Callback.ControlTextChanged(lblCash, user.Money.ToString());//최종 갱신시킴.
        }
    }
}